//通用js封装
/* -----------------------------------时间----------------------------------------- */
/**
 * 获取当前时间
 * @returns {string} yyyy-MM-dd HH:mm:ss
 */
export function getNowTime() {
  const timeStamp = new Date()
  const year = new Date(timeStamp).getFullYear()
  const month =
    new Date(timeStamp).getMonth() + 1 < 10
      ? '0' + (new Date(timeStamp).getMonth() + 1)
      : new Date(timeStamp).getMonth() + 1
  const date =
    new Date(timeStamp).getDate() < 10 ? '0' + new Date(timeStamp).getDate() : new Date(timeStamp).getDate()
  const hh =
    new Date(timeStamp).getHours() < 10 ? '0' + new Date(timeStamp).getHours() : new Date(timeStamp).getHours()
  const mm =
    new Date(timeStamp).getMinutes() < 10
      ? '0' + new Date(timeStamp).getMinutes()
      : new Date(timeStamp).getMinutes()
  const ss =
    new Date(timeStamp).getSeconds() < 10
      ? '0' + new Date(timeStamp).getSeconds()
      : new Date(timeStamp).getSeconds()
  return year + '-' + month + '-' + date + ' ' + hh + ':' + mm + ':' + ss
}

/**
 * 获取当前日期
 * @returns {string} yyyy-MM-dd
 */
export function getNowDate() {
  // 创建一个新的 Date 对象，表示当前日期和时间
  const currentDate = new Date()
  // 获取年份（getFullYear() 方法返回四位数年份）
  const year = currentDate.getFullYear()
  // 获取月份（getMonth() 方法返回的是0-11的整数，所以通常加1来表示实际的月份）
  const month = currentDate.getMonth() + 1
  // 获取日期（getDate() 方法返回的是一个月中的某一天，1-31）
  const day = currentDate.getDate()
  // 将年、月、日组合成一个字符串并输出
  const formattedDate = `${year}-${month < 10 ? '0' : ''}${month}-${day < 10 ? '0' : ''}${day}`
  return formattedDate
}

/**
 * 表格时间格式化
 * @param cellValue 日期字符串 2023-10-03T10:20:30
 * @returns {string}
 */
export function formatDate(cellValue) {
  if (cellValue == null || cellValue == "") return "";
  let date = new Date(cellValue)
  let year = date.getFullYear()
  let month = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1
  let day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate()
  let hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours()
  let minutes = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
  let seconds = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds()
  return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds
}

/**
 * 日期格式化
 * @param {number} time 日期字符串
 * @param {string} option 格式，可以为空 默认yyyy-MM-dd HH:mm:ss
 * @returns {string}
 */
export function formatTime(time, option) {
  if (('' + time).length === 10) {
    time = parseInt(time) * 1000
  } else {
    time = +time
  }
  const d = new Date(time)
  const now = Date.now()

  const diff = (now - d) / 1000

  if (diff < 30) {
    return '刚刚'
  } else if (diff < 3600) {
    // less 1 hour
    return Math.ceil(diff / 60) + '分钟前'
  } else if (diff < 3600 * 24) {
    return Math.ceil(diff / 3600) + '小时前'
  } else if (diff < 3600 * 24 * 2) {
    return '1天前'
  }
  if (option) {
    return parseTime(time, option)
  } else {
    return (
      d.getMonth() +
      1 +
      '月' +
      d.getDate() +
      '日' +
      d.getHours() +
      '时' +
      d.getMinutes() +
      '分'
    )
  }
}

/**
 * 日期格式化
 * @param time 日期对象或字符串
 * @param pattern 格式 默认{y}-{m}-{d} {h}:{i}:{s}
 * @returns {string|null}
 */
export function parseTime(time, pattern) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    if ((typeof time === 'string') && (/^[0-9]+$/.test(time))) {
      time = parseInt(time)
    } else if (typeof time === 'string') {
      time = time.replace(new RegExp(/-/gm), '/').replace('T', ' ').replace(new RegExp(/\.[\d]{3}/gm), '')
    }
    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value]
    }
    if (result.length > 0 && value < 10) {
      value = '0' + value
    }
    return value || 0
  })
  return time_str
}

/**
 * 计算两个时间差经历的时间的文字描述
 * @param start 毫秒
 * @param end 毫秒
 * @returns {string}
 */
export function timeCalculate( start, end ){
  const label = ['分钟', '小时', '天', '月', '年']
  const unit = [60, 60, 24, 30, 12]
  let restTime = Math.floor( ( end - start ) / 1000 )
  let res = ''
  for ( let i = 0, len = unit.length; i < len; i++ ) {
    const pos = len - i // 从年开始算，分钟换算成年 === Math.pow(60, 4)
    const temp = unit.slice( 0, pos ).reduce( ( p, c ) => p * c, 1 )
    const time = Math.floor( restTime / temp )
    time > 0 && ( res += time + label[pos - 1] )
    restTime -= time * temp
  }
  return res
}

/**
 * 计算两个日期相隔的天数
 * @param sDate1 sDate1和sDate2是2006-12-18格式
 * @param sDate2
 * @returns {number}
 */
export function dateDiff(sDate1, sDate2) {
  let aDate, oDate1, oDate2, iDays
  aDate = sDate1.split("-")
  oDate1 = new Date(aDate[0], aDate[1], aDate[2])
  aDate = sDate2.split("-")
  oDate2 = new Date(aDate[0], aDate[1], aDate[2])
  //把相差的毫秒数转换为天数
  iDays = parseInt(Math.abs(oDate1 - oDate2) / 1000 / 60 / 60 / 24)
  return iDays
}

/**
 * 当前时间提示
 * @returns {string}
 */
export function timePrompt () {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : hour <= 11 ? '上午好' : hour <= 13 ? '中午好' : hour < 20 ? '下午好' : '晚上好'
}

/**
 * 订单支付倒计时
 * @param createDate 创建时间（'0000-00-00 00:00:00'）
 * @param limitTimes limitTimes 支付时间，单位分钟
 * @returns {{min: number, second: number}} 剩余支付时间
 */
export function countDown(createDate,limitTimes){
  limitTimes=limitTimes*60
  let now=new Date()
  let create=new Date(createDate)
  let nowSecond=now.getTime()
  let createSecond=create.getTime()
  let countSecond=parseInt((nowSecond-createSecond)/1000)
  let times= limitTimes-countSecond
  if(times<=0){
    times=0;
  }
  let minutes = parseInt(times/60) < 10 ? "0" + parseInt(times/60): parseInt(times/60) ;
  let seconds = parseInt(times%60) < 10 ? "0" + parseInt(times%60): parseInt(times%60);
  return {
    min:minutes,
    second:seconds
  }
}

/* -----------------------------------数值----------------------------------------- */

/**
 * 金额转中文
 * 思路：
 *                             个
 *      十     百      千       万
 *      十万   百万    千万      亿
 *      十亿   百亿    千亿      万亿
 *
 *                              0
 *      1      2       3        4
 *      5      6       7        8
 *      9      10      11       12
 *
 * 计算步骤
 * 1. 获取当前数值大小
 * 2. 排除个位后 数值按个，十，百，千有规律的重复 所以计算其和4的余数 pos % 4
 * 3. 补充最大单位，例如上面第三，四行的万和亿
 *    pos = 0 ~ 3 没有最大单位
 *    pos = 4 ~ 7 最大单位是万
 *    pos = 8 ~ 11 最大单位是亿
 *    pos / 4 的整数就是最大单位
 */
export function getAmountChinese ( val ) {
  const amount = +val
  if ( Number.isNaN( amount ) || amount < 0 ) return ''
  const NUMBER = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']
  const N_UNIT1 = ['', '拾', '佰', '仟']
  const N_UNIT2 = ['', '万', '亿', '万亿']
  const D_UNIT = ['角', '分', '厘', '毫']
  let [integer, decimal] = amount.toString().split( '.' )
  if ( integer && integer.length > 12 ) return '金额过大无法计算'
  let res = ''
  // 整数部分
  if ( integer ) {
    for ( let i = 0, len = integer.length; i < len; i++ ) {
      const num = integer.charAt( i );
      const isZero = num === '0';
      const pos = len - i - 1; // 排除个位后 所处的索引位置
      const isMaxUniPos = pos % 4 === 0;
      const isZeroNext = integer.charAt( i + 1 ) === '0';
      if ( !(isZero && (isZeroNext || isMaxUniPos))) { // 当前位 等于 0 且下一位也等于 0 则可跳过计算
        res += NUMBER[num];
        if (!isZero) res += N_UNIT1[pos % 4];
      }
      if(isMaxUniPos) {
        res += N_UNIT2[Math.floor( pos / 4 )];
      };
    }
    res += '圆'
  }
  // 小数部分
  if ( parseInt( decimal ) ) {
    const loopCount = Math.min(decimal.length, 4);
    for ( let i = 0; i < loopCount; i++ ) {
      const num = decimal.charAt( i )
      if ( num !== '0' ) res += NUMBER[num] + D_UNIT[i];
    }
  } else {
    res += '整'
  }
  return res
}

/**
 * 计算数值的加减乘除,通过补0处理js精度问题
 * @param num1 数值1
 * @param calcStr  操作符 + - * /
 * @param num2 数值2
 * @returns {number|string}
 */
export function calculator(num1,calcStr,num2) {
  let str1, // 转换为字符串的数字
    str2,
    ws1 = 0,// ws1，ws2 用来存储传入的num的小数点后的数字的位数
    ws2 = 0,// 赋默认值，解决当整数和小数运算时倍数计算错误导致的结果误差
    bigger,// bigger和smaller用于加，减，除法找出小的那个数字，给后面补0，解决位数不对从而造成的计算错误的问题；乘法需要将结果除两个数字的倍数之和
    smaller,// 例如：加减除法中1.001 + 2.03 ，如果不给2.03进行补0，最后会变成1001+203，数字错位导致结果错误；乘法中1.12*1.1会放大为112*11，所以结果需要除以1000才会是正确的结果，112*11/1000=1.232
    zeroCount, // 需要补充0的个数
    isExistDot1, // 传入的数字是否存在小数点
    isExistDot2,
    sum,
    beishu = 1
  // 将数字转换为字符串
  str1 = num1.toString()
  str2 = num2.toString()
  // 是否存在小数点（判断需要计算的数字是不是包含小数）
  isExistDot1 = str1.indexOf('.') != -1 ? true : false
  isExistDot2 = str2.indexOf('.') != -1 ? true : false
  // 取小数点后面的位数
  if (isExistDot1) {
    ws1 = str1.split('.')[1].length
  }
  if (isExistDot2) {
    ws2 = str2.split('.')[1].length
  }
  // 如ws1 和 ws2 无默认值，如果num1 或 num2 不是小数的话则 ws1 或 ws2 的值将为 undefined
  // bigger 和 smaller 的值会和预期不符
  bigger = ws1 > ws2 ? ws1 : ws2
  smaller = ws1 < ws2 ? ws1 : ws2
  switch (calcStr) {
    // 加减法找出小的那个数字，给后面补0，解决位数不对从而造成的计算错误的问题
    // 例如：1.001 + 2.03 ，如果不给2.03进行补0，最后会变成1001+203，数字错位导致结果错误
    case '+':
    case '-':
    case '/':
      zeroCount = bigger - smaller
      for (var i = 0; i < zeroCount; i++) {
        if (ws1 == smaller) {
          str1 += '0'
        } else {
          str2 += '0'
        }
      }
      break
    case '*':
      // 乘法需要将结果除两个数字的倍数之和
      bigger = bigger + smaller
      break
    default:
      return '暂不支持的计算类型，现已支持的有加法、减法、乘法、除法'
      break
  }
  // 去除数字中的小数点
  str1 = str1.replace('.', '')
  str2 = str2.replace('.', '')
  // 计算倍数，例如：1.001小数点后有三位，则需要乘 1000 变成 1001，变成整数后精度丢失问题则不会存在
  for (var i = 0; i < bigger; i++) {
    beishu *= 10 // 等价于beishu = beishu * 10;
  }
  num1 = parseInt(str1)
  num2 = parseInt(str2)
  // 进行最终计算并除相应倍数
  switch (calcStr) {
    case '+':
      sum = (num1 + num2) / beishu
      break
    case '-':
      sum = (num1 - num2) / beishu
      break
    case '*':
      sum = (num1 * num2) / beishu
      break
    case '/':
      sum = num1 / num2
      /* 除数与被除数同时放大一定倍数，不影响结果，
      所以对数字进行放大对应倍数并进行补0操作后不用另对倍数做处理 */
      break
    default:
      return '暂不支持的计算类型，现已支持的有加法、减法、乘法、除法'
  }
  return sum
}

/**
 * 去掉小数点后多余的0
 * @param num
 * @returns {string}
 */
export function removeTrailingZeros(num) {
  // 将数字转换为字符串
  let str = num.toString()
  // 如果字符串中不包含小数点，则直接返回
  if (!str.includes('.')) {
    return str
  }
  // 分割字符串为整数部分和小数部分
  let [integerPart, decimalPart] = str.split('.')
  // 去除小数部分末尾的零
  decimalPart = decimalPart.replace(/0+$/, '')
  // 如果小数部分变为空字符串，则只返回整数部分
  if (decimalPart === '') {
    return integerPart
  }
  // 否则，将整数部分和小数部分重新组合并返回
  return integerPart + '.' + decimalPart
}

/* -----------------------------------字符串----------------------------------------- */

/**
 * 验证是否字符串
 * @param {string} str
 * @returns {Boolean}
 */
export function isString(str) {
  if (typeof str === 'string' || str instanceof String) {
    return true
  }
  return false
}

/**
 * 判断字符串是否不为空
 * @param obj
 * @returns {boolean}
 */
export function isNotEmpty(obj) {
  return !(typeof obj == "undefined" || obj == null || obj === "");
}

/**
 * 判断字符串是否为空
 * @param obj
 * @returns {boolean}
 */
export function isEmpty(obj) {
  return typeof obj == "undefined" || obj == null || obj === "";
}

/**
 * 获取一个32位唯一随机字符串
 * @returns {string}
 */
export function getUniqueString() {
  const timestamp = +new Date() + ''
  const randomNum = parseInt((1 + Math.random()) * 65536) + ''
  return (timestamp + randomNum).toString(32)
}

/**
 * 转换字符串，undefined,null等转化为""
 * @param str
 * @returns {*|string}
 */
export function parseStrEmpty(str) {
  if (!str || str == 'undefined' || str == 'null') {
    return ''
  }
  return str
}

/**
 * 首字母大写
 * @param str
 * @returns {*}
 */
export function titleCase(str) {
  return str.replace(/( |^)[a-z]/g, L => L.toUpperCase())
}

/**
 * 下划转驼峰
 * @param str
 * @returns {*}
 */
export function camelCase(str) {
  return str.replace(/_[a-z]/g, str1 => str1.substr(-1).toUpperCase())
}

/**
 * 字符串是否是数值
 * @param str
 * @returns {boolean}
 */
export function isNumberStr(str) {
  return /^[+-]?(0|([1-9]\d*))(\.\d+)?$/g.test(str)
}

/**
 * 获取utf8字符串的字节长度
 * @param {string}
 * @returns {number}
 */
export function getByteLength(str) {
  let s = str.length
  for (var i = str.length - 1; i >= 0; i--) {
    const code = str.charCodeAt(i)
    if (code > 0x7f && code <= 0x7ff) s++
    else if (code > 0x7ff && code <= 0xffff) s += 2
    if (code >= 0xDC00 && code <= 0xDFFF) i--
  }
  return s
}

/* -----------------------------------对象、数组----------------------------------------- */

/**
 * json转字符串
 * @param obj
 * @returns {string}
 */
function stringify(obj) {
  return JSON.stringify(obj, (key, val) => {
    if (typeof val === 'function') {
      return `${val}`
    }
    return val
  })
}

/**
 * 字符串转json
 * @param str
 * @returns {any}
 */
function parse(str) {
  return JSON.parse(str, (k, v) => {
    if (v !== null && v.indexOf && v.indexOf('function') > -1) {
      return eval(`(${v})`)
    }
    return v
  })
}

/**
 * 深拷贝json
 * @param obj
 * @returns {*}
 */
export function jsonClone(obj) {
  return parse(stringify(obj));
}

/**
 * 创建一个值都为true的map
 * @param str 按逗号分隔的key字符串
 * @param expectsLowerCase 是否将key转为小写
 * @returns {{(*): *, (*): *}}
 */
export function makeMap(str, expectsLowerCase) {
  const map = Object.create(null)
  const list = str.split(',')
  for (let i = 0; i < list.length; i++) {
    map[list[i]] = true
  }
  return expectsLowerCase
    ? val => map[val.toLowerCase()]
    : val => map[val]
}

/**
 * 是否是空对象
 * @param obj
 * @returns {boolean}
 */
function isEmptyObj(obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object
}

/**
 * 删除对象中的空值
 * @param data
 * @param recurse
 */
function cleanObject(data, recurse) {
  for (let key in data) {
    if (data[key] === null || data[key] === '' || data[key] === undefined) {
      delete data[key]
    } else if (isEmptyObj(data[key])) {
      delete data[key]
    } else if (recurse && typeof data[key] === 'object') {
      cleanObject(data[key], recurse)
    }
  }
}

/**
 * 这只是深度复制的一个简单版本
 * 有很多边缘案例错误
 * 如果你想使用一个完美的深度副本，请使用lodash库的.cloneDeep
 * @param {Object} source
 * @returns {Object}
 */
export function deepClone(source) {
  if (!source && typeof source !== 'object') {
    throw new Error('参数错误，必须是object', '深度克隆')
  }
  const targetObj = source.constructor === Array ? [] : {}
  Object.keys(source).forEach(keys => {
    if (source[keys] && typeof source[keys] === 'object') {
      targetObj[keys] = deepClone(source[keys])
    } else {
      targetObj[keys] = source[keys]
    }
  })
  return targetObj
}

/**
 * 将两个对象通过key进行合并，当两个对象有相同的key时，以target覆盖
 * @param source
 * @param target
 * @returns {*}
 */
export function mergeRecursive(source, target) {
  for (let p in target) {
    try {
      if (target[p].constructor == Object) {
        source[p] = mergeRecursive(source[p], target[p])
      } else {
        source[p] = target[p]
      }
    } catch (e) {
      source[p] = target[p]
    }
  }
  return source
}

/**
 * 验证是否数组
 * @param {Array} arg
 * @returns {Boolean}
 */
export function isArray(arg) {
  if (typeof Array.isArray === 'undefined') {
    return Object.prototype.toString.call(arg) === '[object Array]'
  }
  return Array.isArray(arg)
}

/**
 * 删除数组中的空值
 * @param {Array} actual
 * @returns {Array} 一个新数组
 */
export function cleanArray(actual) {
  const newArray = []
  for (let i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(actual[i])
    }
  }
  return newArray
}

/**
 * 小数组是否被大数组包含,是返回true,不是返回false
 * @param max 大数组
 * @param min 小数组
 * @returns {boolean}
 */
export function arrayIsContained(max, min){
  if(!(max instanceof Array) || !(min instanceof Array)) return false;
  if(max.length < min.length) return false;
  let aStr = max.toString();
  for(let i = 0, len = min.length; i < len; i++){
    if(aStr.indexOf(min[i]) == -1) return false
  }
  return true
}

/**
 * 根据key对json数组进行排序
 * @param jsonArray
 * @param key json中的key
 * @returns {*}
 */
export function jsonSortByKey(jsonArray,key) {
  return jsonArray.sort(function (a, b) {
    let x = a[key];
    let y = b[key];
    return ((x < y) ? -1 : ((x > y) ? 1 : 0))
  })
}

/**
 * 移除数组中的指定元素
 * @param arr 数组
 * @param val 元素
 */
export function removeByValue(arr, val) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] == val) {
      arr.splice(i, 1)
      break
    }
  }
}

/**
 * 数组去重
 * @param {Array} arr
 * @returns {Array}
 */
export function getUniqueArr(arr) {
  return Array.from(new Set(arr))
}

/* -----------------------------------组件、请求----------------------------------------- */

/**
 * 获取查询路径中的参数
 * @param {string} url 路径，为空默认当前页面路径
 * @returns {Object} json格式
 */
export function getQueryObject(url) {
  url = url == null ? window.location.href : url
  const search = url.substring(url.lastIndexOf('?') + 1)
  const obj = {}
  const reg = /([^?&=]+)=([^?&=]*)/g
  search.replace(reg, (rs, $1, $2) => {
    const name = decodeURIComponent($1)
    let val = decodeURIComponent($2)
    val = String(val)
    obj[name] = val
    return rs
  })
  return obj
}

/**
 * 将json参数转为url参数
 * @param json
 * @returns {string}
 */
export function jsonToParam(json) {
  if (!json) return ''
  return cleanArray(
    Object.keys(json).map(key => {
      if (json[key] === undefined) return ''
      return encodeURIComponent(key) + '=' + encodeURIComponent(json[key])
    })
  ).join('&')
}

/**
 * 将url路径参数转为json
 * @param {string} url
 * @returns {Object}
 */
export function paramToJson(url) {
  const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ')
  if (!search) {
    return {}
  }
  const obj = {}
  const searchArr = search.split('&')
  searchArr.forEach(v => {
    const index = v.indexOf('=')
    if (index !== -1) {
      const name = v.substring(0, index)
      const val = v.substring(index + 1, v.length)
      obj[name] = val
    }
  })
  return obj
}

/**
 * html内容转为文本内容
 * @param {string} val
 * @returns {string}
 */
export function htmlToText(val) {
  const div = document.createElement('div')
  div.innerHTML = val
  return div.textContent || div.innerText
}

/* -----------------------------------css、js----------------------------------------- */

/**
 * 切换样式
 * @param {HTMLElement} element 标签元素
 * @param {string} className 类名
 */
export function toggleClass(element, className) {
  if (!element || !className) {
    return
  }
  let classString = element.className
  const nameIndex = classString.indexOf(className)
  if (nameIndex === -1) {
    classString += '' + className
  } else {
    classString =
      classString.substr(0, nameIndex) +
      classString.substr(nameIndex + className.length)
  }
  element.className = classString
}

/**
 * 检查一个元素是否有某个class属性
 * @param {HTMLElement} elm
 * @param {string} cls
 * @returns {boolean}
 */
export function hasClass(ele, cls) {
  return !!ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'))
}

/**
 * 向一个元素添加class属性
 * @param {HTMLElement} elm
 * @param {string} cls
 */
export function addClass(ele, cls) {
  if (!hasClass(ele, cls)) ele.className += ' ' + cls
}

/**
 * 移除一个元素中的class属性
 * @param {HTMLElement} elm 元素
 * @param {string} cls
 */
export function removeClass(ele, cls) {
  if (hasClass(ele, cls)) {
    const reg = new RegExp('(\\s|^)' + cls + '(\\s|$)')
    ele.className = ele.className.replace(reg, ' ')
  }
}

/**
 * 使div可拖拽
 * @param id 元素的id
 */
export function dragFunc(id) {
  let Drag = document.getElementById(id)
  Drag.onmousedown = function(event) {
    let ev = event || window.event
    event.stopPropagation()
    let disX = ev.clientX - Drag.offsetLeft
    let disY = ev.clientY - Drag.offsetTop
    document.onmousemove = function(event) {
      let ev = event || window.event
      Drag.style.left = ev.clientX - disX + "px"
      Drag.style.top = ev.clientY - disY + "px"
      Drag.style.cursor = "move"
    }
  }
  Drag.onmouseup = function() {
    document.onmousemove = null
    this.style.cursor = "default"
  }
}

/**
 * 防抖函数
 * @param {Function} func 防抖目标函数
 * @param {number} wait 防抖时间间隔
 * @param {boolean} immediate
 * @return {*}
 */
export function debounce(func, wait, immediate) {
  let timeout, args, context, timestamp, result

  const later = function() {
    // 据上一次触发时间间隔
    const last = +new Date() - timestamp

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last)
    } else {
      timeout = null
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args)
        if (!timeout) context = args = null
      }
    }
  }

  return function(...args) {
    context = this
    timestamp = +new Date()
    const callNow = immediate && !timeout
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait)
    if (callNow) {
      result = func.apply(context, args)
      context = args = null
    }

    return result
  }
}

/**
 * 导出js常量
 * @type {string}
 */
export const exportDefault = 'export default '

/**
 * js-beautify插件配置
 */
export const beautifierConf = {
  html: {
    indent_size: '2',
    indent_char: ' ',
    max_preserve_newlines: '-1',
    preserve_newlines: false,
    keep_array_indentation: false,
    break_chained_methods: false,
    indent_scripts: 'separate',
    brace_style: 'end-expand',
    space_before_conditional: true,
    unescape_strings: false,
    jslint_happy: false,
    end_with_newline: true,
    wrap_line_length: '110',
    indent_inner_html: true,
    comma_first: false,
    e4x: true,
    indent_empty_lines: true
  },
  js: {
    indent_size: '2',
    indent_char: ' ',
    max_preserve_newlines: '-1',
    preserve_newlines: false,
    keep_array_indentation: false,
    break_chained_methods: false,
    indent_scripts: 'normal',
    brace_style: 'end-expand',
    space_before_conditional: true,
    unescape_strings: false,
    jslint_happy: true,
    end_with_newline: true,
    wrap_line_length: '110',
    indent_inner_html: true,
    comma_first: false,
    e4x: true,
    indent_empty_lines: true
  }
}

/* -----------------------------------组件----------------------------------------- */
/**
 * 重置表单 el-form组件使用
 * @param refName 元素或组件的ref属性值
 */
export function resetForm(refName) {
  if (this.$refs[refName]) {
    this.$refs[refName].resetFields()
  }
}

/**
 * 向请求参数中添加日期范围
 * @param params 当前请求参数
 * @param dateRange 日期范围数组
 * @param propName 字段名称，为空默认参数名 beginTime endTime
 * @returns {*}
 */
export function addDateRange(params, dateRange, propName) {
  let search = params
  search.params = typeof (search.params) === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {}
  dateRange = Array.isArray(dateRange) ? dateRange : []
  if (typeof (propName) === 'undefined') {
    search.params['beginTime'] = dateRange[0]
    search.params['endTime'] = dateRange[1]
  } else {
    search.params['begin' + propName] = dateRange[0]
    search.params['end' + propName] = dateRange[1]
  }
  return search
}

/**
 * 回显数据字典 单个值
 * @param datas 数据字典数据
 * @param value 当前值 字符串
 * @returns {string} 返回匹配的值，未匹配到会直接显示当前值
 */
export function selectDictLabel(datas, value) {
  if (value === undefined) {
    return ''
  }
  let actions = []
  Object.keys(datas).some((key) => {
    if (datas[key].value == ('' + value)) {
      actions.push(datas[key].label)
      return true
    }
  })
  if (actions.length === 0) {
    actions.push(value)
  }
  return actions.join('')
}

/**
 * 回显数据字典 多个值（字符串、数组）
 * @param datas 数据字典数据
 * @param value 当前值 字符串、数组
 * @param separator 分隔符 默认逗号
 * @returns {string}
 */
export function selectDictLabels(datas, value, separator) {
  if (value === undefined || value.length === 0) {
    return ''
  }
  if (Array.isArray(value)) {
    value = value.join(',')
  }
  let actions = []
  let currentSeparator = undefined === separator ? ',' : separator
  let temp = value.split(currentSeparator)
  Object.keys(value.split(currentSeparator)).some((val) => {
    let match = false
    Object.keys(datas).some((key) => {
      if (datas[key].value == ('' + temp[val])) {
        actions.push(datas[key].label + currentSeparator)
        match = true
      }
    })
    if (!match) {
      actions.push(temp[val] + currentSeparator)
    }
  })
  return actions.join('').substring(0, actions.join('').length - 1)
}

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @returns {*[]} 组装好的树形数据
 */
export function handleTree(data, id, parentId, children) {
  let config = {
    id: id || 'id',
    parentId: parentId || 'parentId',
    childrenList: children || 'children'
  }

  let childrenListMap = {}
  let nodeIds = {}
  let tree = []

  for (let d of data) {
    let parentId = d[config.parentId]
    if (childrenListMap[parentId] == null) {
      childrenListMap[parentId] = []
    }
    nodeIds[d[config.id]] = d
    childrenListMap[parentId].push(d)
  }

  for (let d of data) {
    let parentId = d[config.parentId]
    if (nodeIds[parentId] == null) {
      tree.push(d)
    }
  }

  for (let t of tree) {
    adaptToChildrenList(t)
  }

  function adaptToChildrenList(o) {
    if (childrenListMap[o[config.id]] !== null) {
      o[config.childrenList] = childrenListMap[o[config.id]]
    }
    if (o[config.childrenList]) {
      for (let c of o[config.childrenList]) {
        adaptToChildrenList(c)
      }
    }
  }

  return tree
}

/**
 * 请求参数处理
 * @param {*} params  参数
 */
export function tansParams(params) {
  let result = ''
  for (const propName of Object.keys(params)) {
    const value = params[propName]
    let part = encodeURIComponent(propName) + '='
    if (value !== null && value !== '' && typeof (value) !== 'undefined') {
      if (typeof value === 'object') {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && value[key] !== '' && typeof (value[key]) !== 'undefined') {
            let params = propName + '[' + key + ']'
            let subPart = encodeURIComponent(params) + '='
            result += subPart + encodeURIComponent(value[key]) + '&'
          }
        }
      } else {
        result += part + encodeURIComponent(value) + '&'
      }
    }
  }
  return result
}

/* -----------------------------------其它----------------------------------------- */

/**
 * 验证是否为blob格式
 * @param data
 * @returns {boolean}
 */
export function blobValidate(data) {
  return data.type !== 'application/json'
}

/**
 * 获取当前登录设备信息
 * 根据屏幕尺寸，浏览器信息综合判断当前浏览器是否是移动端
 * @returns {Object} 包含设备类型和详细信息的对象
 */
export function detectDevice() {
  // 1. 基础信息收集
  const userAgent = navigator.userAgent;
  const screenWidth = window.innerWidth;
  const screenHeight = window.innerHeight;
  const pixelRatio = window.devicePixelRatio || 1;
  // 2. 多维度检测
  const isMobileUA = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent);
  const isTabletUA = /iPad|Android|Tablet|Silk/i.test(userAgent) && !/Mobile/i.test(userAgent);
  const hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
  const isSmallScreen = screenWidth < 768 && screenHeight < 1024;
  const isHighDPI = pixelRatio >= 2;
  // 3. 设备类型判断逻辑
  let deviceType = 'desktop';
  let deviceSubType = 'standard';
  if (isTabletUA) {
    deviceType = 'tablet';
  } else if (isMobileUA || (hasTouch && isSmallScreen)) {
    deviceType = 'mobile';
  }
  // 4. 额外特征检测
  const isIOS = /iPhone|iPad|iPod/i.test(userAgent);
  const isAndroid = /Android/i.test(userAgent);
  const isWeChat = /MicroMessenger/i.test(userAgent);
  // 5. 返回完整设备信息
  return {
    type: deviceType,
    subType: deviceSubType,
    isMobile: deviceType === 'mobile' || deviceType === 'tablet',
    isDesktop: deviceType === 'desktop',
    isTablet: deviceType === 'tablet',
    isIOS,
    isAndroid,
    isWeChat,
    screen: {
      width: screenWidth,
      height: screenHeight,
      pixelRatio
    },
    userAgent
  }


}
